import java.security.spec.RSAOtherPrimeInfo;

//内部类
class OuterClass {
    public int data1 = 10;
    private int data2 = 20;
    public static int data3 = 30;
    //实例内部类
    class InnerClass{
        public int data1 = 1111;
        public int data4 = 40;
        private int data5 = 50;
//        public static int data6 = 60;//会报错，所以在实例内部类里面不能定义静态成员变量
        public static final int data6 = 60;//final修饰的变量为常量，常量是在编译的时候就已经确定了
        public void testInner(){
            System.out.println("testInner");
            System.out.println(data1);//此时输出1111
            System.out.println(OuterClass.this.data1);//此时输出10
            System.out.println(data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);

        }//内部类里面也可以定义方法
    }
    public void testOut(){
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.data5);
    }//在外部类里面访问内部类中的成员，必须先创建内部类对象
}

class OuterClass2{
    public int data1 = 10;
    private int data2 = 20;
    public static int data3 = 30;
    static class InnerClass{
        int data4 = 40;
        private int data5 = 50;
        public static int data6 = 60;
        public void testInner(){
            System.out.println("testInner");
//            System.out.println(data1);
//            System.out.println(data2);//外部类的非静态成员变量不能直接访问
            System.out.println(data3);//静态内部类可以直接访问外部类的静态成员变量，但是不能直接访问外部类的非静态成员变量，访问的话需要实例化外部类对象：
            OuterClass2 outerClass2 = new OuterClass2();
            System.out.println(outerClass2.data1);
            System.out.println(outerClass2.data2);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
}

//局部内部类
class OuterClass3{

    public void test(){
        class InnerClass{
            public int data1 = 10;
        }
        InnerClass innerClass = new InnerClass();//局部内部类的实例化只能在当前所以的外部类方法或者{}里面，所以一般使用的较少
        System.out.println(innerClass.data1);
    }
//    InnerClass innerClass = new InnerClass();//此时由于实例化的地方不对就会报错

}

//匿名内部类
class Student implements Comparable<Student>{
    @Override
    public int compareTo(Student o) {
        return 0;
    }
}
interface Shape{
    public void draw();
}

public class Test {
    public static void main(String[] args) {
        new Comparable<Student>(){
            @Override
            public int compareTo(Student o) {
                return 0;
            }
        };
        //实现了接口的实例化并重写了接口里面的方法
        new Shape(){
            @Override
            public void draw() {
                System.out.println("画矩形！");
            }
        };

    }
    public static void main2(String[] args) {
        //静态内部类的实例化
        OuterClass2.InnerClass innerClass2 = new OuterClass2.InnerClass();//静态内部类的实例化不需要外部类对象作为前提，所以一般使用静态内部类多一些
        innerClass2.testInner();
    }
    public static void main1(String[] args) {
        OuterClass outerClass = new OuterClass();
        //下面进行实例内部类的实例化
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();//左边前面表示类型，后面表示变量，右边是外部类对象的引用进行内部类的实例化
        //以上两行可以通过一行来实现
//        OuterClass.InnerClass innerClass1 = new OuterClass().new InnerClass();
        innerClass.testInner();
    }
}

